home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / hity wydania / Blender 2.49b / blender-2.49b-windows.exe / $_4_ / .blender / scripts / mesh_solidify.py < prev    next >
Text File  |  2009-08-31  |  10KB  |  345 lines
  1. #!BPY
  2. """
  3. Name: 'Solidify Selection'
  4. Blender: 243
  5. Group: 'Mesh'
  6. Tooltip: 'Makes the mesh solid by creating a second skin.'
  7. """
  8.  
  9. __author__ = "Campbell Barton"
  10. __url__ = ("www.blender.org", "blenderartists.org")
  11. __version__ = "1.1"
  12.  
  13. __bpydoc__ = """\
  14. This script makes a skin from the selected faces.
  15. Optionaly you can skin between the original and new faces to make a watertight solid object
  16. """
  17.  
  18. # -------------------------------------------------------------------------- 
  19. # Solidify Selection 1.0 by Campbell Barton (AKA Ideasman42) 
  20. # -------------------------------------------------------------------------- 
  21. # ***** BEGIN GPL LICENSE BLOCK ***** 
  22. # 
  23. # This program is free software; you can redistribute it and/or 
  24. # modify it under the terms of the GNU General Public License 
  25. # as published by the Free Software Foundation; either version 2 
  26. # of the License, or (at your option) any later version. 
  27. # 
  28. # This program is distributed in the hope that it will be useful, 
  29. # but WITHOUT ANY WARRANTY; without even the implied warranty of 
  30. # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
  31. # GNU General Public License for more details. 
  32. # 
  33. # You should have received a copy of the GNU General Public License 
  34. # along with this program; if not, write to the Free Software Foundation, 
  35. # Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA. 
  36. # 
  37. # ***** END GPL LICENCE BLOCK ***** 
  38. # -------------------------------------------------------------------------- 
  39.  
  40. from Blender import *
  41. import bpy
  42. import BPyMesh
  43. # reload(BPyMesh)
  44. import BPyMessages
  45. # reload(BPyMessages)
  46.  
  47. from BPyMathutils import angleToLength
  48.  
  49. # python 2.3 has no reversed() iterator. this will only work on lists and tuples
  50. try:
  51.     reversed
  52. except:
  53.     def reversed(l): return l[::-1]
  54.  
  55. def copy_facedata_multilayer(me, from_faces, to_faces):
  56.     '''
  57.     Tkes 2 lists of faces and copies multilayer data from 1 to another
  58.     make sure they are aligned, cant copy from a quad to a tri, used for solidify selection.
  59.     '''
  60.     
  61.     def copy_default_face(data):
  62.         face_from, face_to = data
  63.         face_to.mat = face_from.mat
  64.         face_to.smooth = face_from.smooth
  65.         face_to.sel = True
  66.         face_from.sel = False
  67.     
  68.     def copy_tex_face(data):
  69.         face_from, face_to = data
  70.         face_to.uv = [c for c in reversed(face_from.uv)]
  71.         face_to.mode = face_from.mode
  72.         face_to.flag = face_from.flag
  73.         face_to.image = face_from.image
  74.     
  75.     def copy_col_face(data):
  76.         face_from, face_to = data
  77.         face_to.col = [c for c in reversed(face_from.col)]
  78.     
  79.     # make a list of face_from, face_to pairs
  80.     #face_pairs = zip(faces_sel, [me_faces[len_faces + i] for i in xrange(len(faces_sel))])
  81.     face_pairs = zip(from_faces, to_faces)
  82.     
  83.     # Copy properties from 1 set of faces to another.
  84.     map(copy_default_face, face_pairs)
  85.     
  86.     for uvlayer in me.getUVLayerNames():
  87.         me.activeUVLayer = uvlayer
  88.         map(copy_tex_face, face_pairs)
  89.     
  90.     for collayer in me.getColorLayerNames():
  91.         me.activeColorLayer = collayer
  92.         map(copy_col_face, face_pairs)
  93.     
  94.     # Now add quads between if we wants
  95.  
  96.  
  97. Ang= Mathutils.AngleBetweenVecs
  98. SMALL_NUM=0.00001
  99.  
  100. def solidify(me, PREF_THICK, PREF_SKIN_SIDES=True, PREF_REM_ORIG=False, PREF_COLLAPSE_SIDES=False):
  101.     
  102.     # Main code function
  103.     me_faces = me.faces
  104.     faces_sel= [f for f in me_faces if f.sel]
  105.     
  106.     BPyMesh.meshCalcNormals(me)
  107.     normals= [v.no for v in me.verts]
  108.     vertFaces= [[] for i in xrange(len(me.verts))]
  109.     for f in me_faces:
  110.         no=f.no
  111.         for v in f:
  112.             vertFaces[v.index].append(no)
  113.     
  114.     # Scale the normals by the face angles from the vertex Normals.
  115.     for i in xrange(len(me.verts)):
  116.         length=0.0
  117.         if vertFaces[i]:
  118.             for fno in vertFaces[i]:
  119.                 try:
  120.                     a= Ang(fno, normals[i])
  121.                 except:
  122.                     a= 0    
  123.                 if a>=90:
  124.                     length+=1
  125.                 elif a < SMALL_NUM:
  126.                     length+= 1
  127.                 else:
  128.                     length+= angleToLength(a)
  129.             
  130.             length= length/len(vertFaces[i])
  131.             #print 'LENGTH %.6f' % length
  132.             # normals[i]= (normals[i] * length) * PREF_THICK
  133.             normals[i] *= length * PREF_THICK
  134.             
  135.             
  136.     
  137.     len_verts = len( me.verts )
  138.     len_faces = len( me_faces )
  139.     
  140.     vert_mapping= [-1] * len(me.verts)
  141.     verts= []
  142.     for f in faces_sel:
  143.         for v in f:
  144.             i= v.index
  145.             if vert_mapping[i]==-1:
  146.                 vert_mapping[i]= len_verts + len(verts)
  147.                 verts.append(v.co + normals[i])
  148.     
  149.     #verts= [v.co + normals[v.index] for v in me.verts]
  150.     
  151.     me.verts.extend( verts )
  152.     #faces= [tuple([ me.verts[v.index+len_verts] for v in reversed(f.v)]) for f in me_faces ]
  153.     faces= [ tuple([vert_mapping[v.index] for v in reversed(f.v)]) for f in faces_sel ]
  154.     me_faces.extend( faces )
  155.     
  156.  
  157.     
  158.     
  159.     # Old method before multi UVs
  160.     """
  161.     has_uv = me.faceUV
  162.     has_vcol = me.vertexColors
  163.     for i, orig_f in enumerate(faces_sel):
  164.         new_f= me_faces[len_faces + i]
  165.         new_f.mat = orig_f.mat
  166.         new_f.smooth = orig_f.smooth
  167.         orig_f.sel=False
  168.         new_f.sel= True
  169.         new_f = me_faces[i+len_faces]
  170.         if has_uv:
  171.             new_f.uv = [c for c in reversed(orig_f.uv)]
  172.             new_f.mode = orig_f.mode
  173.             new_f.flag = orig_f.flag
  174.             if orig_f.image:
  175.                 new_f.image = orig_f.image
  176.         if has_vcol:
  177.             new_f.col = [c for c in reversed(orig_f.col)]
  178.     """
  179.     copy_facedata_multilayer(me, faces_sel, [me_faces[len_faces + i] for i in xrange(len(faces_sel))])
  180.     
  181.     if PREF_SKIN_SIDES or PREF_COLLAPSE_SIDES:
  182.         skin_side_faces= []
  183.         skin_side_faces_orig= []
  184.         # Get edges of faces that only have 1 user - so we can make walls
  185.         edges = {}
  186.         
  187.         # So we can reference indicies that wrap back to the start.
  188.         ROT_TRI_INDEX = 0,1,2,0
  189.         ROT_QUAD_INDEX = 0,1,2,3,0
  190.         
  191.         for f in faces_sel:
  192.             f_v= f.v
  193.             for i, edgekey in enumerate(f.edge_keys):
  194.                 if edges.has_key(edgekey):
  195.                     edges[edgekey]= None
  196.                 else:
  197.                     if len(f_v) == 3:
  198.                         edges[edgekey] = f, f_v, i, ROT_TRI_INDEX[i+1]
  199.                     else:
  200.                         edges[edgekey] = f, f_v, i, ROT_QUAD_INDEX[i+1]
  201.         del ROT_QUAD_INDEX, ROT_TRI_INDEX
  202.         
  203.         # So we can remove doubles with edges only.
  204.         if PREF_COLLAPSE_SIDES:
  205.             me.sel = False
  206.         
  207.         # Edges are done. extrude the single user edges.
  208.         for edge_face_data in edges.itervalues():
  209.             if edge_face_data: # != None
  210.                 f, f_v, i1, i2 = edge_face_data
  211.                 v1i,v2i= f_v[i1].index, f_v[i2].index
  212.                 
  213.                 if PREF_COLLAPSE_SIDES:
  214.                     # Collapse
  215.                     cv1 = me.verts[v1i]
  216.                     cv2 = me.verts[vert_mapping[v1i]]
  217.                     
  218.                     cv3 = me.verts[v2i]
  219.                     cv4 = me.verts[vert_mapping[v2i]]
  220.                     
  221.                     cv1.co = cv2.co = (cv1.co+cv2.co)/2
  222.                     cv3.co = cv4.co = (cv3.co+cv4.co)/2
  223.                     
  224.                     cv1.sel=cv2.sel=cv3.sel=cv4.sel=True
  225.                     
  226.                     
  227.                     
  228.                 else:
  229.                     # Now make a new Face
  230.                     # skin_side_faces.append( (v1i, v2i, vert_mapping[v2i], vert_mapping[v1i]) )
  231.                     skin_side_faces.append( (v2i, v1i, vert_mapping[v1i], vert_mapping[v2i]) )
  232.                     skin_side_faces_orig.append((f, len(me_faces) + len(skin_side_faces_orig), i1, i2))
  233.         
  234.         if PREF_COLLAPSE_SIDES:
  235.             me.remDoubles(0.0001)
  236.         else:
  237.             me_faces.extend(skin_side_faces)
  238.             # Now assign properties.
  239.             """
  240.             # Before MultiUVs
  241.             for i, origfData in enumerate(skin_side_faces_orig):
  242.                 orig_f, new_f_idx, i1, i2 = origfData
  243.                 new_f= me_faces[new_f_idx]
  244.                 
  245.                 new_f.mat= orig_f.mat
  246.                 new_f.smooth= orig_f.smooth
  247.                 if has_uv:
  248.                     new_f.mode= orig_f.mode
  249.                     new_f.flag= orig_f.flag
  250.                     if orig_f.image:
  251.                         new_f.image= orig_f.image
  252.                     
  253.                     uv1= orig_f.uv[i1]
  254.                     uv2= orig_f.uv[i2]
  255.                     new_f.uv= (uv1, uv2, uv2, uv1)
  256.                 
  257.                 if has_vcol:
  258.                     col1= orig_f.col[i1]
  259.                     col2= orig_f.col[i2]
  260.                     new_f.col= (col1, col2, col2, col1)
  261.             """
  262.             
  263.             for i, origfData in enumerate(skin_side_faces_orig):
  264.                 orig_f, new_f_idx, i2, i1 = origfData
  265.                 new_f= me_faces[new_f_idx]
  266.                 
  267.                 new_f.mat= orig_f.mat
  268.                 new_f.smooth= orig_f.smooth
  269.             
  270.             for uvlayer in me.getUVLayerNames():
  271.                 me.activeUVLayer = uvlayer
  272.                 for i, origfData in enumerate(skin_side_faces_orig):
  273.                     orig_f, new_f_idx, i2, i1 = origfData
  274.                     new_f= me_faces[new_f_idx]
  275.                     
  276.                     new_f.mode= orig_f.mode
  277.                     new_f.flag= orig_f.flag
  278.                     new_f.image= orig_f.image
  279.                     
  280.                     uv1= orig_f.uv[i1]
  281.                     uv2= orig_f.uv[i2]
  282.                     new_f.uv= (uv1, uv2, uv2, uv1)
  283.             
  284.             for collayer in me.getColorLayerNames():
  285.                 me.activeColorLayer = collayer
  286.                 for i, origfData in enumerate(skin_side_faces_orig):
  287.                     orig_f, new_f_idx, i2, i1 = origfData
  288.                     new_f= me_faces[new_f_idx]
  289.                     
  290.                     col1= orig_f.col[i1]
  291.                     col2= orig_f.col[i2]
  292.                     new_f.col= (col1, col2, col2, col1)
  293.         
  294.     
  295.     if PREF_REM_ORIG:
  296.         me_faces.delete(0, faces_sel)
  297.  
  298.  
  299.  
  300.  
  301. def main():
  302.     scn = bpy.data.scenes.active
  303.     ob = scn.objects.active
  304.     
  305.     if not ob or ob.type != 'Mesh':
  306.         BPyMessages.Error_NoMeshActive()
  307.         return
  308.     
  309.     me = ob.getData(mesh=1)
  310.     if me.multires:
  311.         BPyMessages.Error_NoMeshMultiresEdit()
  312.         return
  313.     
  314.     # Create the variables.
  315.     PREF_THICK = Draw.Create(-0.1)
  316.     PREF_SKIN_SIDES= Draw.Create(1)
  317.     PREF_COLLAPSE_SIDES= Draw.Create(0)
  318.     PREF_REM_ORIG= Draw.Create(0)
  319.     
  320.     pup_block = [\
  321.     ('Thick:', PREF_THICK, -10, 10, 'Skin thickness in mesh space.'),\
  322.     ('Skin Sides', PREF_SKIN_SIDES, 'Skin between the original and new faces.'),\
  323.     ('Collapse Sides', PREF_COLLAPSE_SIDES, 'Skin between the original and new faces.'),\
  324.     ('Remove Original', PREF_REM_ORIG, 'Remove the selected faces after skinning.'),\
  325.     ]
  326.     
  327.     if not Draw.PupBlock('Solid Skin Selection', pup_block):
  328.         return
  329.     
  330.     is_editmode = Window.EditMode() 
  331.     if is_editmode: Window.EditMode(0)
  332.     
  333.     Window.WaitCursor(1)
  334.     
  335.     me = ob.getData(mesh=1)
  336.     solidify(me, PREF_THICK.val, PREF_SKIN_SIDES.val, PREF_REM_ORIG.val, PREF_COLLAPSE_SIDES.val)
  337.     
  338.     
  339.     Window.WaitCursor(0)
  340.     if is_editmode:    Window.EditMode(1)
  341.     
  342.     Window.RedrawAll()
  343.  
  344. if __name__ == '__main__':
  345.     main()